home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / xinu.arc / XINUC3.C < prev   
Text File  |  1986-01-03  |  15KB  |  567 lines
  1. /* queue.c - dequeue, enqueue  p. 46 */
  2.  
  3. # include    <conf.h>
  4. # include    <kernel.h>
  5. # include    <q.h>
  6.  
  7. /*-----------------------------------------------------------------------------
  8.  * enqueue  --  insert an item at the tail of a list
  9.  *-----------------------------------------------------------------------------
  10.  */
  11. int    enqueue(item,tail)
  12.     int    item;            /* item to enqueue on a list         */
  13.     int    tail;            /* index in q of list tail           */
  14. {
  15.     struct qent    *tptr;        /* points to tail entry              */
  16.     struct qent    *mptr;        /* points to item entry              */
  17.  
  18.     tptr = &q[tail];
  19.     mptr = &q[item];
  20.     mptr->qnext = tail;
  21.     mptr->qprev = tptr->qprev;
  22.     q[tptr->qprev].qnext = item;
  23.     tptr->qprev = item;
  24.     return(item);
  25. }
  26.  
  27. /*-----------------------------------------------------------------------------
  28.  * dequeue  --  remove an item from a list and return it
  29.  *-----------------------------------------------------------------------------
  30.  */
  31. int    dequeue(item)
  32.     int    item;
  33. {
  34.     struct qent    *mptr;        /* pointer to q entry for item       */
  35.  
  36.     mptr = &q[item];
  37.     q[mptr->qprev].qnext = mptr->qnext;
  38.     q[mptr->qnext].qprev = mptr->qprev;
  39.     return(item);
  40. }
  41. /* rdisk.c - rdinit rdopen rdread rdwrite */
  42.  
  43. # include    <conf.h>
  44. # include    <kernel.h>
  45. # include    <disk.h>
  46. # include    <file.h>
  47. # include    <dir.h>
  48.  
  49. # ifdef    Ndsk
  50. struct dsblk    dstab[Ndsk];
  51. # endif
  52. int    dskdbp, dskrbp;
  53.  
  54. /*-----------------------------------------------------------------------------
  55.  *  rdinit  --  initialize ram disk device
  56.  *-----------------------------------------------------------------------------
  57.  */
  58. rdinit(devptr)
  59.     struct devsw    *devptr;
  60. {
  61.     struct dsblk    *dsptr;
  62.     struct dtc    *dtptr;
  63.     int    status;
  64.     int    ps;    
  65.  
  66.     ps = disable();
  67.     dsptr = &dstab[devptr->dvminor];
  68.     devptr->dvioblk = (char *)dsptr;
  69.     dsptr->dcsr    = (struct dtc *)devptr->dvcsr;
  70.     dsptr->dreqlst = DRNULL;
  71.     dsptr->dnum    = devptr->dvnum;
  72.     dsptr->dibsem  = screate(1);
  73.     dsptr->dflsem  = screate(1);
  74.     dsptr->ddirsem = screate(1);
  75.     dsptr->dnfiles = 0;
  76.     dsptr->ddir    = (char *)getbuf(dskdbp);
  77. è    /* read directory block; setup read command then start interface */
  78.  
  79.     rdread ( devptr, dsptr->ddir, DIRBLK );
  80.     restore(ps);
  81.     return(OK);
  82. }
  83.  
  84.  
  85. /*-----------------------------------------------------------------------------
  86.  *  rdopen  --  open/create a file on the specified ram disk device
  87.  *-----------------------------------------------------------------------------
  88.  */
  89. rdopen(devptr, filenam, mode)
  90.     struct devsw    *devptr;
  91.     char    *filenam;
  92.     char    *mode;
  93. {
  94.     struct dir    *dirptr;
  95.     struct flblk    *flptr;
  96.     struct fdes    *fdptr;
  97.     DBADDR    dba;
  98.     int    mbits, findex;
  99.     int    retcode;
  100.     int    ps;
  101.     extern struct fdes    *dfdsrch();
  102.  
  103.     ps = disable();
  104.     dirptr = dsdirec(devptr->dvnum);
  105.     if ((mbits=dfckmd(mode)) == SYSERR)
  106.         retcode = SYSERR;
  107.     else if ((fdptr=dfdsrch(devptr->dvioblk,filenam,mbits)) 
  108.                 == (struct fdes *)SYSERR)
  109.         retcode = SYSERR;
  110.     else if ((findex=dfalloc()) == SYSERR)
  111.         retcode = SYSERR;
  112.     else  {
  113.         flptr = &fltab[findex];
  114.         flptr->fl_dev = devptr->dvnum;
  115.         flptr->fl_dent = fdptr;
  116.         flptr->fl_mode = mbits & FLRW;
  117.         flptr->fl_iba = fdptr->fdiba;
  118.         ibget(flptr->fl_dev,flptr->fl_iba,&(flptr->fl_iblk));
  119.         flptr->fl_pos = 0L;
  120.         flptr->fl_dch = FALSE;
  121.         dba = flptr->fl_iblk.ib_dba[flptr->fl_ipnum = 0];
  122.         if (dba != DBNULL)  {
  123.             read(flptr->fl_dev, flptr->fl_buff, dba);
  124.             flptr->fl_bptr = flptr->fl_buff;
  125.         }  else
  126.             flptr->fl_bptr = &flptr->fl_buff[DBUFSIZ];
  127.         retcode = flptr->fl_id;
  128.     }
  129.     restore(ps);
  130.     return(retcode);
  131. }è
  132.  
  133. /*-----------------------------------------------------------------------------
  134.  *  rdread  --  read from ram disk
  135.  *-----------------------------------------------------------------------------
  136.  */
  137. rdread(devptr, buff, block)
  138.     struct devsw    *devptr;
  139.     char    *buff;
  140.     DBADDR    block;
  141. {
  142.     char    *from, *to;
  143.     int    i;
  144.  
  145.     from = (char *)((long)block * (long)DBUFSIZ + (long)devptr->dvcsr );
  146.     to = buff;
  147.     for ( i = 0; i < DBUFSIZ; i++ )  {
  148.         *to++ = *from++;
  149.     }
  150.     return(OK);
  151. }
  152.  
  153.  
  154. /*-----------------------------------------------------------------------------
  155.  *  rdwrite  --  write to ram disk
  156.  *-----------------------------------------------------------------------------
  157.  */
  158. rdwrite(devptr, buff, block)
  159.     struct devsw    *devptr;
  160.     char    *buff;
  161.     DBADDR    block;
  162. {
  163.     char    *from, *to;
  164.     int    i;
  165.  
  166.     from = buff;
  167.     to = (char *)((long)block * (long)DBUFSIZ + (long)devptr->dvcsr );
  168.     for ( i = 0; i < DBUFSIZ; i++ )  {
  169.         *to++ = *from++;
  170.     }
  171.     freebuf(buff);
  172.     return(OK);
  173. }
  174. /* read.c - read  p. 145 */
  175.  
  176. # include    <conf.h>
  177. # include    <kernel.h>
  178. # include    <io.h>
  179.  
  180. /*-----------------------------------------------------------------------------
  181.  *  read  --  read one or more bytes from a device
  182.  *-----------------------------------------------------------------------------
  183.  */
  184. read(descrp, buff, count)
  185.     int    descrp, count;
  186.     char    *buff;
  187. {
  188.     struct devsw    *devptr;
  189.  
  190.     if (isbaddev(descrp))
  191.         return(SYSERR);
  192.     devptr = &devtab[descrp];
  193.     return ((*devptr->dvread)(devptr,buff,count));
  194. }
  195. /* ready.c - ready  p. 62 */
  196.  
  197. # include    <conf.h>
  198. # include    <kernel.h>
  199. # include    <proc.h>
  200. # include    <q.h>
  201.  
  202. /*-----------------------------------------------------------------------------
  203.  * ready  --  make a process eligible for CPU service
  204.  *-----------------------------------------------------------------------------
  205.  */
  206. int    ready (pid, resch)
  207.     int    pid;            /* id of process to make ready       */
  208.     int    resch;            /* reschedule afterward?             */
  209. {
  210.     register struct pentry    *pptr;
  211.  
  212.     if (isbadpid(pid))
  213.         return(SYSERR);
  214.     pptr = &proctab[pid];
  215.     pptr->pstate = PRREADY;
  216.     insert(pid,rdyhead,pptr->pprio);
  217.     if (resch)
  218.         resched();
  219.     return(OK);
  220. }
  221. /* receive.c - receive  p. 97 */
  222.  
  223. # include    <conf.h>
  224. # include    <kernel.h>
  225. # include    <proc.h>
  226.  
  227. /*-----------------------------------------------------------------------------
  228.  *  receive  --  wait for a message and return it
  229.  *-----------------------------------------------------------------------------
  230.  */
  231. SYSCALL    receive()
  232. {
  233.     struct pentry    *pptr;
  234.     int    msg;
  235.     char    ps;
  236.  
  237.     disable(ps);
  238.     pptr = &proctab[currpid];
  239.     if (pptr->phasmsg == 0)  {    /* if no message, wait for one       */
  240.         pptr->pstate = PRRECV;
  241.         resched();
  242.     }
  243.     msg = pptr->pmsg;        /* retrieve message                  */
  244.     pptr->phasmsg = 0;
  245.     restore(ps);
  246.     return(msg);
  247. }
  248. /* recvclr.c - recvclr  p. 98 */
  249.  
  250. # include    <conf.h>
  251. # include    <kernel.h>
  252. # include    <proc.h>
  253.  
  254. /*-----------------------------------------------------------------------------
  255.  *  recvclr  --  clear messages, returning waiting message ( if any )
  256.  *-----------------------------------------------------------------------------
  257.  */
  258. SYSCALL    recvclr()
  259. {
  260.     char    ps;
  261.     int    msg;
  262.  
  263.     disable(ps);
  264.     if (proctab[currpid].phasmsg)  {    /* existing message          */
  265.         proctab[currpid].phasmsg = 0;
  266.         msg = proctab[currpid].pmsg;
  267.     }  else
  268.         msg = OK;
  269.     restore(ps);
  270.     return(msg);
  271. }
  272. /* resched.c - resched  p. 58 */
  273.  
  274. # include    <conf.h>
  275. # include    <kernel.h>
  276. # include    <proc.h>
  277. # include    <q.h>
  278.  
  279. /*-----------------------------------------------------------------------------
  280.  * resched  --  reschedule processor to highest priority ready process
  281.  *
  282.  * Notes:       Upon entry, currpid gives current process id.
  283.  *              Proctab[currpid].pstate gives correct NEXT state for
  284.  *                      current process if other than PRREADY.
  285.  *-----------------------------------------------------------------------------
  286.  */
  287. int    resched()
  288. {
  289.     register struct pentry    *optr;    /* pointer to old process entry      */
  290.     register struct pentry    *nptr;    /* pointer to new process entry      */
  291.  
  292.     /* no switch needed if current process priority higher than next */
  293.  
  294.     if ( ( (optr= &proctab[currpid])->pstate == PRCURR) &&
  295.        (lastkey(rdytail)<optr->pprio))
  296.         return ( OK );
  297.  
  298.     /* force context switch */
  299.  
  300.     if (optr->pstate == PRCURR)  {
  301.         optr->pstate = PRREADY;
  302.         insert(currpid,rdyhead,optr->pprio);
  303.     }
  304.  
  305.     /* remove highest priority process at end of ready list */
  306.  
  307.     nptr = &proctab[ (currpid = getlast(rdytail)) ];
  308.     nptr->pstate = PRCURR;        /* mark it currently running         */
  309. # ifdef    RTCLOCK
  310.     preempt = QUANTUM;        /* reset preemption counter          */
  311. # endif
  312.     ctxsw(optr->pregs,nptr->pregs);
  313.  
  314.     /* the old process returns here when resumed. */
  315.     return(OK);
  316. }
  317. /* resume.c - resume  p. 66 */
  318.  
  319. # include    <conf.h>
  320. # include    <kernel.h>
  321. # include    <proc.h>
  322.  
  323. /*-----------------------------------------------------------------------------
  324.  * resume  --  unsuspend a process, making it ready; return the priority
  325.  *-----------------------------------------------------------------------------
  326.  */
  327. SYSCALL    resume(pid)
  328.     int    pid;
  329. {
  330.     char    ps;            /* saved processor status            */
  331.     struct pentry    *pptr;        /* pointer to proccess table entry   */
  332.     int    prio;            /* priority to return                */
  333.  
  334.     disable(ps);
  335.     if (isbadpid(pid) || (pptr = &proctab[pid])->pstate != PRSUSP)  {
  336.         restore(ps);
  337.         return(SYSERR);
  338.     }
  339.     prio = pptr->pprio;
  340.     ready(pid, RESCHYES);
  341.     restore(ps);
  342.     return(prio);
  343. }
  344. /* screate.c - screate, newsem  p. 88 */
  345.  
  346. # include    <conf.h>
  347. # include    <kernel.h>
  348. # include    <proc.h>
  349. # include    <q.h>
  350. # include    <sem.h>
  351.  
  352. /*-----------------------------------------------------------------------------
  353.  * screate  --  create and initialize a semaphore, returning its id
  354.  *-----------------------------------------------------------------------------
  355.  */
  356. SYSCALL    screate(count)
  357.     int    count;            /* initial count (>=0)               */
  358. {
  359.     char    ps;
  360.     int    sem;
  361.  
  362.     disable(ps);
  363.     if ( count<0 || (sem=newsem())==SYSERR )  {
  364.         restore(ps);
  365.         return(SYSERR);
  366.     }
  367.     semaph[sem].semcnt = count;
  368.     /* sqhead and sqtail were initialized at system startup */
  369.     restore(ps);
  370.     return(sem);
  371. }
  372.  
  373. /*-----------------------------------------------------------------------------
  374.  * newsem  --  allocate an unused semaphore and return its index
  375.  *-----------------------------------------------------------------------------
  376.  */
  377. LOCAL    newsem()
  378. {
  379.     int    sem;
  380.     int    i;
  381.  
  382.     for (i=0 ; i<NSEM ; i++)  {
  383.         sem = nextsem--;
  384.         if (nextsem < 0)
  385.             nextsem = NSEM-1;
  386.         if (semaph[sem].sstate==SFREE)  {
  387.             semaph[sem].sstate = SUSED;
  388.             return(sem);
  389.         }
  390.     }
  391.     return(SYSERR);
  392. }
  393. /* sdelete.c - sdelete  p. 89 */
  394.  
  395. # include    <conf.h>
  396. # include    <kernel.h>
  397. # include    <proc.h>
  398. # include    <q.h>
  399. # include    <sem.h>
  400.  
  401. /*-----------------------------------------------------------------------------
  402.  * sdelete  --  delete a semaphore by releasing its table entry
  403.  *-----------------------------------------------------------------------------
  404.  */
  405. SYSCALL    sdelete(sem)
  406.     int    sem;
  407. {
  408.     char    ps;
  409.     int    pid;
  410.     struct sentry    *sptr;        /* address of sem to free           */
  411.  
  412.     disable(ps);
  413.     if (isbadsem(sem) || semaph[sem].sstate==SFREE)  {
  414.         restore(ps);
  415.         return(SYSERR);
  416.     }
  417.     sptr = &semaph[sem];
  418.     sptr->sstate = SFREE;
  419.     if (nonempty(sptr->sqhead))  {    /* free waiting process             */
  420.         while ((pid=getfirst(sptr->sqhead)) != EMPTY)
  421.             ready(pid,RESCHNO);
  422.         resched();
  423.     }
  424.     restore(ps);
  425.     return(OK);
  426. }
  427. /* seek.c - seek  p. 148 */
  428.  
  429. # include    <conf.h>
  430. # include    <kernel.h>
  431. # include    <io.h>
  432.  
  433. /*-----------------------------------------------------------------------------
  434.  *  seek  --  position a device (very common special case of control)
  435.  *-----------------------------------------------------------------------------
  436.  */
  437. seek(descrp, pos)
  438.     int    descrp;
  439.     long    pos;
  440. {
  441.     struct devsw    *devptr;
  442.  
  443.     if (isbaddev(descrp))
  444.         return(SYSERR);
  445.     devptr = &devtab[descrp];
  446.     return ((*devptr->dvseek)(devptr,pos));
  447. }
  448. /* send.c - send  p. 96 */
  449.  
  450. # include    <conf.h>
  451. # include    <kernel.h>
  452. # include    <proc.h>
  453.  
  454. /*-----------------------------------------------------------------------------
  455.  *  send  --  send a message to another process
  456.  *-----------------------------------------------------------------------------
  457.  */
  458. SYSCALL    send(pid, msg)
  459.     int    pid;
  460.     int    msg;
  461. {
  462.     struct pentry    *pptr;        /* receiver's process table address  */
  463.     char    ps;
  464.  
  465.     disable(ps);
  466.     if (isbadpid(pid) || ((pptr= &proctab[pid])->pstate == PRFREE)
  467.        || pptr->phasmsg != 0)  {
  468.         restore(ps);
  469.         return(SYSERR);
  470.     }
  471.     pptr->pmsg = msg;        /* deposit message                   */
  472.     pptr->phasmsg++;
  473.     if (pptr->pstate == PRRECV)    /* if receiver waits, start it       */
  474.         ready(pid, RESCHYES);
  475.     restore(ps);
  476.     return(OK);
  477. }
  478. /* signal.c - signal  p. 86 */
  479.  
  480. # include    <conf.h>
  481. # include    <kernel.h>
  482. # include    <proc.h>
  483. # include    <q.h>
  484. # include    <sem.h>
  485.  
  486. /*-----------------------------------------------------------------------------
  487.  * signal  --  signal a semaphore, releasing one waiting process
  488.  *-----------------------------------------------------------------------------
  489.  */
  490. SYSCALL    signal(sem)
  491.     register int    sem;
  492. {
  493.     register struct sentry    *sptr;
  494.     char    ps;
  495.  
  496.     disable(ps);
  497.     if (isbadsem(sem) || (sptr = &semaph[sem])->sstate==SFREE)  {
  498.         restore(ps);
  499.         return(SYSERR);
  500.     }
  501.     if ((sptr->semcnt++) < 0)
  502.         ready(getfirst(sptr->sqhead),RESCHYES);
  503.     restore(ps);
  504.     return(OK);
  505. }
  506. /* sleep.c - sleep  p. 132 */
  507.  
  508. # include    <conf.h>
  509. # include    <kernel.h>
  510. # include    <proc.h>
  511. # include    <q.h>
  512. # include    <sleep.h>
  513.  
  514. /*-----------------------------------------------------------------------------
  515.  *  sleep  --  delay the calling process n seconds
  516.  *-----------------------------------------------------------------------------
  517.  */
  518. SYSCALL    sleep(n)
  519.     int    n;
  520. {
  521.     if (n<0 || clkruns==0)
  522.         return(SYSERR);
  523.     if (n == 0)  {
  524.         resched();
  525.         return(OK);
  526.     }
  527.     while (n >= 1000)  {
  528.         sleep10(10000);
  529.         n -= 1000;
  530.     }
  531.     if (n > 0)
  532.         sleep10(10*n);
  533.     return(OK);
  534. }
  535. /* sleep10.c - sleep10  p. 129 */
  536.  
  537. # include    <conf.h>
  538. # include    <kernel.h>
  539. # include    <proc.h>
  540. # include    <q.h>
  541. # include    <sleep.h>
  542.  
  543. /*-----------------------------------------------------------------------------
  544.  *  sleep10  --  delay the caller for a time specified in tenths of seconds
  545.  *-----------------------------------------------------------------------------
  546.  */
  547. SYSCALL    sleep10(n)
  548.     int    n;
  549. {
  550.     char    ps;
  551.  
  552.     if (n < 0 || clkruns==0)
  553.         return(SYSERR);
  554.     if (n == 0)  {
  555.         resched();        /* sleep10(0) -> end time slice      */
  556.         return(OK);
  557.     }
  558.     disable(ps);
  559.     insertd(currpid,clockq,n);
  560.     slnempty = TRUE;
  561.     sltop = &q[q[clockq].qnext].qkey;
  562.     proctab[currpid].pstate = PRSLEEP;
  563.     resched();
  564.     restore(ps);
  565.     return(OK);
  566. }
  567.